home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / music / cthugha5.zip / CTHU5SRC.ZIP / CDPLYR.C < prev    next >
C/C++ Source or Header  |  1994-08-19  |  16KB  |  890 lines
  1. #include <stdlib.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4.  
  5. #ifdef _MSC_VER
  6. #include <bios.h>
  7. #endif
  8.  
  9. #include "cthugha.h"
  10. #include "zorilkey.h"
  11. #include "mouse.h"
  12. #include "cdmixrg.c"
  13.  
  14. #include "sb_drive.h"
  15. #include "cdmaster.h"
  16.  
  17. #include "initscrn.h"
  18. #include "patch.h"
  19.  
  20. #define disp(x,y,z) { pokeb(0xB800,(160*(y))+(14+6*(x)),(z) ? '█' : '░'); pokeb(0xB800,(160*(y))+(16+6*(x)),(z) ? '█' : '░' ); }
  21. #define volbar(y,level) { int i; for( i=0; i<16; i++ ) pokeb(0xB800,(160*(y))+(124+2*i),(level/16) > i ? '■' : ' '); }
  22. #define invert(x) pokeb(0xB800,1+(2*(x)),0x40 ^ peekb(0xB800,1+(2*(x))));
  23.  
  24. #define outc(x,y,z) pokeb(0xB800,(160*(y))+(2*(x)),(z))
  25. #define outn(x,y,z); { outc(x,y,(z) > 99 ? 48+(((z)/100)%10) : ' '); outc(x+1,y,((z)>9) ? 48+(((z)/10)%10) : ' '); outc(x+2,y,48+((z)%10)); };
  26.  
  27. #define MIXmic MIXmicrophone
  28.  
  29. extern enum device_list { CDInput, LineInput, MicInput } device;
  30.  
  31. void disp_num(int x, int y, int num);
  32. int get_levels(int *left, int *right);
  33.  
  34. extern int curpal;
  35. extern int numluts;
  36.  
  37. int lasttrack,stopflag = 0;
  38.  
  39. extern int mouse_inst;
  40.  
  41. extern int debug_mode;
  42. extern int SBtype;
  43.  
  44. extern int (*init_audio)(void);
  45. extern int (*close_audio)(void);
  46. extern int (*audio_firsttime)(void);
  47. extern int (*audio_everytime)(int wait);
  48.  
  49. extern int (*get_level)(int channel);
  50. extern void (*set_level)(int channel, int level);
  51. extern int  (*level_incr)(int channel);
  52.  
  53. extern void (*set_input)(enum device_list device);
  54.  
  55. void cd_playtrack(int track);
  56. void cd_playpause(void);
  57. void cd_backtrack(void);
  58. void cd_fwdtrack(void);
  59. void cd_backscan(void);
  60. void cd_fwdscan(void);
  61. void cd_stop(void);
  62.  
  63. void vu(int level, int y)
  64. {
  65.     disp(10,y,level==255);
  66.     disp(9,y,level>220);
  67.     disp(8,y,level>>7);
  68.     disp(7,y,level>>6);
  69.     disp(6,y,level>>5);
  70.     disp(5,y,level>>4);
  71.     disp(4,y,level>>3);
  72.     disp(3,y,level>>2);
  73.     disp(2,y,level>>1);
  74.     disp(1,y,level);
  75. }
  76.  
  77. void choose_track(void)
  78. {
  79. //    char scrbuf[200];
  80.  
  81.     char *disp_ptr;
  82.  
  83.     int i,j;
  84.     int leave;
  85.     int track;
  86.  
  87.     static char trackmsg[] =
  88.         "█▀▀█ █▀▀█   ▀█▀ █▀▄ ▄▀▄ ▄▀ █ █"
  89.         "█  █ █  █    █  █▀▄ █▀█ █  █▀▄"
  90.         "▀▀▀▀ ▀▀▀▀    ▀  ▀ ▀ ▀ ▀  ▀ ▀ ▀";
  91.  
  92.     if( lasttrack == -1 )
  93.         return;
  94.  
  95. //    gettext(48,18,77,20,scrbuf);
  96.  
  97.     disp_ptr = trackmsg;
  98.  
  99.     for( i = 0; i < 3; i++ )
  100.         for( j = 0; j < 30; j++ )
  101.             outc(47+j,17+i,*disp_ptr++);
  102.  
  103.     leave = 0;
  104.     track = 0;
  105.  
  106.     while( !leave )
  107.     {
  108.         if( get_levels(&i,&j) )
  109.         {
  110.             vu(i,8);
  111.             vu(j,10);
  112.         }
  113.  
  114.         i = 0;
  115.  
  116.         if( kbhit() )
  117.             i = getch();
  118.  
  119.         if( i == 27 )
  120.             leave = 1;
  121.  
  122.         if( i == 13 )
  123.         {
  124.             if( (track > 0) && (track <= lasttrack) )
  125.                 cd_playtrack(track);
  126.  
  127.             leave = 1;
  128.         }
  129.  
  130.         if( i >= '0' && i <= '9' )
  131.         {
  132.             track = (track%10)*10 + (i-48);
  133.  
  134.             disp_num(47,17,track);
  135.         }
  136.     }
  137.  
  138. //    puttext(48,18,77,20,scrbuf);
  139. }
  140.  
  141.  
  142. void cd_backscan(void)
  143. {
  144.     struct cdtable *cdt;
  145.     int ourdrive;
  146.     int tracknum;
  147.  
  148.     struct qchaninfo qci;
  149.  
  150.     stopflag = 0;
  151.  
  152.     ourdrive = getfirstcdrom();
  153.     cdt = createaudiotoc(ourdrive);
  154.  
  155.     cdqchaninfo(ourdrive,&qci);
  156.  
  157.     qci.track = (qci.track/16)*10 + (qci.track%16);
  158.  
  159.     playcdtrack(ourdrive,qci.track,(qci.min*60)+qci.sec-15,-1);
  160.  
  161.     destroyaudiotoc(ourdrive);
  162. }
  163.  
  164. void cd_fwdscan(void)
  165. {
  166.     struct cdtable *cdt;
  167.     int ourdrive;
  168.     int tracknum;
  169.  
  170.     struct qchaninfo qci;
  171.  
  172.     stopflag = 0;
  173.  
  174.     ourdrive = getfirstcdrom();
  175.     cdt = createaudiotoc(ourdrive);
  176.  
  177.     cdqchaninfo(ourdrive,&qci);
  178.  
  179.     qci.track = (qci.track/16)*10 + (qci.track%16);
  180.  
  181.     playcdtrack(ourdrive,qci.track,(qci.min*60)+qci.sec+15,-1);
  182.  
  183.     destroyaudiotoc(ourdrive);
  184. }
  185.  
  186. void cd_backtrack(void)
  187. {
  188.     struct cdtable *cdt;
  189.     int ourdrive;
  190.     int tracknum;
  191.  
  192.     struct qchaninfo qci;
  193.  
  194.     stopflag = 0;
  195.  
  196.     ourdrive = getfirstcdrom();
  197.     cdt = createaudiotoc(ourdrive);
  198.  
  199.     cdqchaninfo(ourdrive,&qci);
  200.  
  201.     qci.track = (qci.track/16)*10 + (qci.track%16);
  202.  
  203.     if( (qci.min) || (qci.sec > 2) )
  204.         playcdtrack(ourdrive,qci.track  ,0,-1);
  205.     else
  206.         playcdtrack(ourdrive,qci.track-1,0,-1);
  207.  
  208.     destroyaudiotoc(ourdrive);
  209. }
  210.  
  211. void cd_fwdtrack(void)
  212. {
  213.     struct cdtable *cdt;
  214.     int ourdrive;
  215.     int tracknum;
  216.  
  217.     struct qchaninfo qci;
  218.  
  219.     stopflag = 0;
  220.  
  221.     ourdrive = getfirstcdrom();
  222.     cdt = createaudiotoc(ourdrive);
  223.  
  224.     cdqchaninfo(ourdrive,&qci);
  225.  
  226.     qci.track = (qci.track/16)*10 + (qci.track%16);
  227.  
  228.     playcdtrack(ourdrive,qci.track+1,0,-1);
  229.  
  230.     destroyaudiotoc(ourdrive);
  231. }
  232.  
  233. void cd_playtrack(int track)
  234. {
  235.     struct cdtable *cdt;
  236.     int ourdrive;
  237.     int tracknum;
  238.  
  239.     ourdrive = getfirstcdrom();
  240.     cdt = createaudiotoc(ourdrive);
  241.  
  242.     stopflag = 0;
  243.  
  244.     playcdtrack(ourdrive,track,0,-1);
  245.  
  246.     destroyaudiotoc(ourdrive);
  247. }
  248.  
  249. void cd_playpause(void)
  250. {
  251.     struct cdtable *cdt;
  252.     struct trackinfo ti;
  253.     int ourdrive;
  254.     int tracknum;
  255.  
  256.     long frames,f;
  257.  
  258.     stopflag = 0;
  259.  
  260.     ourdrive = getfirstcdrom();
  261.     cdt = createaudiotoc(ourdrive);
  262.  
  263.     if( cdstatus(ourdrive) & CDISPAUSED )
  264.         cdresume(ourdrive);
  265.     else
  266.     {
  267.         if( cdstatus(ourdrive) & CDISPLAYING )
  268.             cdpause(ourdrive);
  269.         else
  270.             playcdtrack(ourdrive,1,0,-1);
  271.     }
  272.  
  273.     destroyaudiotoc(ourdrive);
  274. }
  275.  
  276. void cd_stop(void)
  277. {
  278.     struct cdtable *cdt;
  279.     struct trackinfo ti;
  280.     int ourdrive;
  281.  
  282.     ourdrive = getfirstcdrom();
  283.     cdt = createaudiotoc(ourdrive);
  284.  
  285.     if( (cdstatus(ourdrive) & CDISPLAYING) || (cdstatus(ourdrive) & CDISPAUSED) )
  286.     {
  287.         cdstop(ourdrive);
  288.         cdreset(ourdrive);
  289.  
  290.         stopflag = 60;
  291.     }
  292.     else
  293.         cdeject(ourdrive);
  294.  
  295.     destroyaudiotoc(ourdrive);
  296. }
  297.  
  298. void disp_num(int x, int y, int num)
  299. {
  300.     int i,j;
  301.     char *ptr1,*ptr2;
  302.  
  303.     static char numbers[10][12] =
  304.     {
  305.         "█▀▀█"
  306.         "█  █"
  307.         "▀▀▀▀",
  308.         " ▄█ "
  309.         "  █ "
  310.         "  ▀ ",
  311.         "▀▀▀█"
  312.         "█▀▀▀"
  313.         "▀▀▀▀",
  314.         "▀▀▀█"
  315.         "▀▀▀█"
  316.         "▀▀▀▀",
  317.         "█  █"
  318.         "▀▀▀█"
  319.         "   ▀",
  320.         "█▀▀▀"
  321.         "▀▀▀█"
  322.         "▀▀▀▀",
  323.         "█▀▀▀"
  324.         "█▀▀█"
  325.         "▀▀▀▀",
  326.         "▀▀▀█"
  327.         " ▄▀ "
  328.         " ▀  ",
  329.         "█▀▀█"
  330.         "█▀▀█"
  331.         "▀▀▀▀",
  332.         "█▀▀█"
  333.         "▀▀▀█"
  334.         "▀▀▀▀"
  335.     };
  336.  
  337.     if( num > 99 )
  338.         num = 99;
  339.  
  340.     ptr1 = numbers[num / 10];
  341.     ptr2 = numbers[num % 10];
  342.  
  343.     for( j = 0; j < 3; j++ )
  344.         for( i = 0; i < 4; i++ )
  345.         {
  346.             outc(  x+i,y+j,*ptr1++);
  347.             outc(5+x+i,y+j,*ptr2++);
  348.         }
  349. }
  350.  
  351. void cd_display(void)
  352. {
  353.     struct cdtable *cdt;
  354.     int ourdrive;
  355.  
  356.     struct qchaninfo qci;
  357.  
  358.     static long lasttime,thistime;
  359.  
  360.     char *disp_ptr;
  361.  
  362.     int stat;
  363.  
  364.     int i,j;
  365.  
  366.     static char nodisc[] =
  367.         "█▄ █ ▄▀▀▄   █▀▀▄ █ ▄▀▀▀ ▄▀▀▀  "
  368.         "█ ▀█ █  █   █  █ █  ▀▀▄ █     "
  369.         "▀  ▀  ▀▀    ▀▀▀  ▀ ▀▀▀   ▀▀▀  ";
  370.  
  371.     static char stopped[] =
  372.         "█▀▀█ █▀▀█   ▄▀▀▀ ▀█▀ ▄▀▀▄ █▀▀▄"
  373.         "█  █ █  █    ▀▀▄  █  █  █ █▀▀ "
  374.         "▀▀▀▀ ▀▀▀▀   ▀▀▀   ▀   ▀▀  ▀   ";
  375. #ifdef _MSC_VER
  376.     _bios_timeofday(_TIME_GETCLOCK,&thistime);
  377. #else
  378.     thistime = biostime(0,0);
  379. #endif
  380.  
  381.     if( (thistime > lasttime) && (thistime < (lasttime+5)) )
  382.         return;
  383.  
  384.     lasttime = thistime;
  385.  
  386.     ourdrive = getfirstcdrom();
  387.     cdt = createaudiotoc(ourdrive);
  388.  
  389.     if( stopflag > 1 )
  390.         stopflag--;
  391.  
  392.     if( (stopflag<2) && (!(isanaudiocd(ourdrive))) )
  393.     {
  394.         disp_ptr = nodisc;
  395.  
  396.         lasttrack = -1;
  397.  
  398.         for( i = 0; i < 3; i++ )
  399.             for( j = 0; j < 30; j++ )
  400.                 outc(47+j,17+i,*disp_ptr++);
  401.  
  402.         outc(44,17,32);
  403.         outc(45,17,32);
  404.  
  405.         for( i = 0; i < 10; i++ )
  406.         {
  407.             outc(47+3*i,21,' ');
  408.             outc(48+3*i,21,' ');
  409.             outc(47+3*i,23,' ');
  410.             outc(48+3*i,23,' ');
  411.         }
  412.  
  413.         outc(77,22,' ');
  414.         outc(78,22,' ');
  415.  
  416.         return;
  417.     }
  418.  
  419.     if( lasttrack == -1 )
  420.     {
  421.         struct discinfo di;
  422.  
  423.         cddiscinfo(ourdrive,&di);
  424.  
  425.         lasttrack = di.ltrk;
  426.  
  427.         if( lasttrack > 0 )
  428.         {
  429.             for( i = 0; i < 10; i++ )
  430.             {
  431.                 outc(47+3*i,21,' ');
  432.                 outc(48+3*i,21,' ');
  433.                 outc(47+3*i,23,' ');
  434.                 outc(48+3*i,23,' ');
  435.  
  436.                 if( lasttrack > i )
  437.                     outc(48+3*i,21, i==9 ? 48 : i+49);
  438.  
  439.                 if( lasttrack > (i+10) )
  440.                 {
  441.                     outc(48+3*i,23, i==9 ? 48 : i+49);
  442.                     outc(47+3*i,23,'1');
  443.                 }
  444.             }
  445.  
  446.             if( lasttrack >= 10 )
  447.                 outc(74,21,'1');
  448.  
  449.             if( lasttrack >= 20 )
  450.                 outc(74,23,'2');
  451.  
  452.             if( lasttrack > 20 )
  453.             {
  454.                 outc(77,22,48+lasttrack/10);
  455.                 outc(78,22,48+lasttrack%10);
  456.             }
  457.  
  458.             stopflag = 0;
  459.         }
  460.         else
  461.             lasttrack = -1;
  462.     }
  463.  
  464.     if( (stopflag) || !((stat=cdstatus(ourdrive))&CDISPLAYING) && !(stat&CDISPAUSED) )
  465.     {
  466.         disp_ptr = stopped;
  467.  
  468.         if( !stopflag )
  469.             stopflag = 1;
  470.  
  471.         for( i = 0; i < 3; i++ )
  472.             for( j = 0; j < 30; j++ )
  473.                 outc(47+j,17+i,*disp_ptr++);
  474.  
  475.         outc(44,17,32);
  476.         outc(45,17,32);
  477.  
  478.         return;
  479.     }
  480.  
  481.     outc(62,17,' ');
  482.     outc(62,18,' ');
  483.     outc(62,19,' ');
  484.  
  485.     outc(67,17,'■');
  486.     outc(67,18,'■');
  487.     outc(67,19,' ');
  488.  
  489.     outc(72,17,' ');
  490.     outc(72,18,' ');
  491.     outc(72,19,' ');
  492.  
  493.     if( stat&CDISPAUSED )
  494.     {
  495.         outc(44,17,'▌');
  496.         outc(45,17,'▐');
  497.     }
  498.     else if( stat&CDISPLAYING )
  499.     {
  500.         outc(44,17,32);
  501.         outc(45,17,16);
  502.     }
  503.  
  504.     cdqchaninfo(ourdrive,&qci);
  505.  
  506.     disp_num(47,17,(qci.track/16)*10+(qci.track%16));
  507.     disp_num(58,17,qci.min  );
  508.     disp_num(68,17,qci.sec  );
  509.  
  510.     destroyaudiotoc(ourdrive);
  511. }
  512.  
  513. void display_window(enum device_list device)
  514. {
  515.  
  516.     static char windows[3][42] =
  517.     {
  518.         "▄▀▀▀  █▀▀▄    "
  519.         "█     █  █    "
  520.         "▀▄▄▄  █▄▄▀    ",
  521.  
  522.         "█   █ █▄ █ █▀▀"
  523.         "█   █ █ ▀█ █▀▀"
  524.         "█▄▄ █ █  █ █▄▄",
  525.  
  526.         "█▄ ▄█ █ ▄▀▀▀  "
  527.         "█ █ █ █ █     "
  528.         "█   █ █ ▀▄▄▄  "
  529.     };
  530.  
  531.     int i,j;
  532.  
  533.     char *cptr;
  534.  
  535.     cptr = windows[device];
  536.  
  537.     for( j = 0; j < 3; j++ )
  538.         for( i = 0; i < 14; i++ )
  539.             pokeb(0xB800,(160*(j+12))+(50+2*i),*cptr++);
  540. }
  541.  
  542. void cd_player(void)
  543. {
  544.     int m1,m2,m3,m4;
  545.  
  546.     int leave = 0;
  547.     int count;
  548.  
  549.     int CDok;
  550.  
  551.     union REGS regset;
  552.  
  553.     int mx,my;
  554.  
  555.     char action, cursor = 'A';
  556.  
  557.     regset.x.ax = 0x0003;    /* AL = 3 selects 80x25 text mode */
  558.     int86(0x10, ®set, ®set);
  559.  
  560.     CDok = 1;
  561.  
  562.     lasttrack = -1;
  563.  
  564.     if( !ismscdex() )
  565.         CDok = 0;
  566.  
  567.     if( !getnumcdroms() )
  568.         CDok = 0;
  569.  
  570.     cdmix_screen(CDok);
  571.  
  572.     if( CDok )
  573.         cd_display();
  574.  
  575.     display_window(device);
  576.  
  577.     volbar( 8,get_level(MIXmaster));
  578.     volbar( 9,get_level(MIXcd));
  579.     volbar(10,get_level(MIXline));
  580.     volbar(11,get_level(MIXmicrophone));
  581.  
  582.     outn(59,14,((long)get_level(MIXtreble)*107)/255);
  583.     outc(62,14,'%')
  584.     outn(70,14,((long)get_level(MIXbass)*107)/255);
  585.     outc(73,14,'%');
  586.  
  587.     gotoxy(80,25);
  588.  
  589.     if( mouse_inst )
  590.     {
  591.         m1 = MOUSE_RESET;
  592.         mouse_call(&m1,&m2,&m3,&m4);
  593.  
  594.         m1 = SHOW_CURSOR;
  595.         mouse_call(&m1,&m2,&m3,&m4);
  596.     }
  597.  
  598.     for( m1 = 0; m1 < 2000; m1++ )
  599.         if( CDMIX_REGION[m1] == cursor )
  600.             invert(m1);
  601.  
  602.     while( !leave )
  603.     {
  604.         m2 = 0;
  605.  
  606.         action = 0;
  607.  
  608.         if( mouse_inst )
  609.         {
  610.             m1 = GET_POSITION;
  611.             mouse_call(&m1,&m2,&m3,&m4);
  612.         }
  613.         while( !action )
  614.         {
  615.             if( CDok )
  616.                 cd_display();
  617.  
  618.             if( get_levels(&m1,&m2) )
  619.             {
  620.                 vu(m1,8);
  621.                 vu(m2,10);
  622.  
  623.                 m2 = 0;
  624.             }
  625.  
  626.             if( mouse_inst )
  627.             {
  628.                 m1 = GET_POSITION;
  629.                 mouse_call(&m1,&m2,&m3,&m4);
  630.  
  631.                 if( m2==1 )
  632.                 {
  633.                     delay(20);
  634.                     count++;
  635.  
  636.                         if( count > 99 )
  637.                              count = -7;       // Delay before repeat
  638.                         else
  639.                              if( count < 5 )   // Repeat rate
  640.                                   m2 = 0;
  641.                              else
  642.                                   count = 0;
  643.                 }
  644.                 else
  645.                     count = 99;
  646. /*                if( m2 )
  647.                 {
  648.                     gotoxy(0,0);
  649.                     printf("%i %i   ",(m3/8),(m4/8));
  650.                 }
  651. */            }
  652.  
  653.             if( m2 )
  654.             {
  655.                 mx = m3 /= 8;
  656.                 my = m4 /= 8;
  657.  
  658.                 if( CDMIX_REGION[(80*m4)+m3] != ' ' )
  659.                 {
  660.                     m1 = HIDE_CURSOR; mouse_call(&m1,&m2,&m3,&m4);
  661.  
  662.                     for( m1 = 0; m1 < 2000; m1++ )
  663.                         if( CDMIX_REGION[m1] == cursor )
  664.                             invert(m1);
  665.  
  666.                     action = CDMIX_REGION[(80*m4)+m3];
  667.  
  668.                     if( !CDok )
  669.                         if( (action > 'L') || (action == '-') )
  670.                             action = ' ';
  671.                         else
  672.                         {
  673.                             if( action != '-' )
  674.                                 cursor = action;
  675.                             else
  676.                                 cursor = 'S';
  677.                         }
  678.                     else
  679.                     {
  680.                         if( action != '-' )
  681.                             cursor = action;
  682.                         else
  683.                             cursor = 'S';
  684.                     }
  685.  
  686.                     for( m1 = 0; m1 < 2000; m1++ )
  687.                         if( CDMIX_REGION[m1] == cursor )
  688.                             invert(m1);
  689.  
  690.                     m1 = SHOW_CURSOR; mouse_call(&m1,&m2,&m3,&m4);
  691.                 }
  692.             }
  693.  
  694.             if( kbhit() )
  695.             {
  696.                 m2 = getch();
  697.                 if( !m2 )
  698.                     m2 = getch() + 256;
  699.  
  700.                 if( mouse_inst )
  701.                 {
  702.                     m1 = HIDE_CURSOR;
  703.                     mouse_call(&m1,&m2,&m3,&m4);
  704.                 }
  705.  
  706.                 for( m1 = 0; m1 < 2000; m1++ )
  707.                     if( CDMIX_REGION[m1] == cursor )
  708.                         invert(m1);
  709.  
  710.                 switch( m2 )
  711.                 {
  712.                     case 256+0x50: cursor++; if( cursor > (CDok ? CDMIX_REGION_END : 'L') ) cursor = 'A'; break;
  713.                     case 256+0x48: cursor--; if( cursor < 'A' ) cursor = (CDok ? CDMIX_REGION_END : 'L'); break;
  714.  
  715.                     case ' ':    action = cursor; break;
  716.                     case 13 :     action = cursor; break;
  717.                     case 27 :   action = 'A';    break;
  718.                 }
  719.  
  720.                 for( m1 = 0; m1 < 2000; m1++ )
  721.                     if( CDMIX_REGION[m1] == cursor )
  722.                         invert(m1);
  723.  
  724.                 if( mouse_inst )
  725.                 {
  726.                     m1 = SHOW_CURSOR;
  727.                     mouse_call(&m1,&m2,&m3,&m4);
  728.                 }
  729.  
  730.             }
  731.         }
  732.  
  733.         switch( action )
  734.         {
  735.             case 'A' : leave = 1; break;
  736.  
  737.             case 'B' : device = CDInput;   set_input(device); display_window(device); break;
  738.             case 'C' : device = LineInput; set_input(device); display_window(device); break;
  739.             case 'D' : device = MicInput;  set_input(device); display_window(device); break;
  740.  
  741.             case 'E' :
  742. #if 0
  743.                 m2 = mix_read(MIXmaster,MIXboth)+(SBtype>3?8:32);
  744.                 m2 = min(m2,255);
  745.  
  746.                 mix_write(MIXmaster,MIXboth,m2);
  747.  
  748.                 break;
  749. #else
  750.                 m2 = get_level(MIXmaster)+(SBtype>3?8:32);
  751.                 m2 = min(m2,255);
  752.                 set_level(MIXmaster,m2);
  753.                 break;
  754. #endif
  755.             case 'F' :
  756. #if 0
  757.                 m2 = mix_read(MIXmaster,MIXboth)-(SBtype>3?8:32);
  758.                 m2 = max(m2,0);
  759.  
  760.                 mix_write(MIXmaster,MIXboth,m2);
  761.  
  762.                 break;
  763. #else
  764.                 m2 = get_level(MIXmaster)-(SBtype>3?8:32);
  765.                 m2 = min(m2,255);
  766.                 set_level(MIXmaster,m2);
  767.                 break;
  768. #endif
  769.  
  770.             case 'G' : switch( device )
  771.                           {
  772.                               case CDInput  : m2 = get_level(MIXcd);
  773.                                                     m2 += level_incr(MIXcd);
  774.                                                     break;
  775.                               case LineInput: m2 = get_level(MIXline);
  776.                                                     m2 += level_incr(MIXline);
  777.                                                     break;
  778.                               case MicInput : m2 = get_level(MIXmic);
  779.                                                     m2 += level_incr(MIXmic);
  780.                                                     break;
  781.                           }
  782.  
  783.                           m2=min(m2,255);
  784.  
  785.                           switch( device )
  786.                           {
  787.                                 case CDInput  : set_level(MIXcd  ,m2); break;
  788.                                 case LineInput: set_level(MIXline,m2); break;
  789.                                 case MicInput : set_level(MIXmic ,m2); break;
  790.                           }
  791.  
  792.                           break;
  793.  
  794.             case 'H' : switch( device )
  795.                           {
  796.                               case CDInput  : m2 = get_level(MIXcd);
  797.                                                     m2 -= level_incr(MIXcd);
  798.                                                     break;
  799.                               case LineInput: m2 = get_level(MIXline);
  800.                                                     m2 -= level_incr(MIXline);
  801.                                                     break;
  802.                               case MicInput : m2 = get_level(MIXmic);
  803.                                                     m2 -= level_incr(MIXmic);
  804.                                                     break;
  805.                           }
  806.  
  807.                           m2=max(m2,0);
  808.  
  809.                           switch( device )
  810.                           {
  811.                                 case CDInput  : set_level(MIXcd  ,m2); break;
  812.                                 case LineInput: set_level(MIXline,m2); break;
  813.                                 case MicInput : set_level(MIXmic ,m2); break;
  814.                           }
  815.  
  816.                           break;
  817.  
  818.             case 'I' : m2 = get_level(MIXtreble)+level_incr(MIXtreble);
  819.                           m2 = min(m2,255);
  820.  
  821.                           set_level(MIXtreble,m2);
  822.  
  823.                           break;
  824.  
  825.             case 'J' : m2 = get_level(MIXtreble)-level_incr(MIXtreble);
  826.                           m2 = max(m2,0);
  827.  
  828.                           set_level(MIXtreble,m2);
  829.  
  830.                           break;
  831.  
  832.             case 'K' : m2 = get_level(MIXbass)+level_incr(MIXbass);
  833.                           m2 = min(m2,255);
  834.  
  835.                           set_level(MIXbass,m2);
  836.  
  837.                           break;
  838.  
  839.             case 'L' : m2 = get_level(MIXbass)-level_incr(MIXbass);
  840.                           m2 = max(m2,0);
  841.  
  842.                           set_level(MIXbass,m2);
  843.  
  844.                           break;
  845.  
  846.             case 'M' : cd_playpause();  break;
  847.             case 'N' : cd_backtrack();  break;
  848.             case 'O' : cd_fwdtrack();   break;
  849.             case 'P' : cd_backscan();   break;
  850.             case 'Q' : cd_fwdscan();    break;
  851.             case 'R' : cd_stop();          break;
  852.  
  853.             case 'S' : choose_track();  break;
  854.  
  855.             case '-' : mx -= 47;
  856.                           mx /= 3;
  857.  
  858.                           if( my == 21 )
  859.                                 m2 = 1+mx;
  860.                           else
  861.                                 m2 = 11+mx;
  862.  
  863.                           cd_playtrack(m2);    break;
  864.  
  865.         }
  866.  
  867.         if( (action >= 'E') && (action <= 'L') )
  868.         {
  869.             volbar( 8,get_level(MIXmaster));
  870.             volbar( 9,get_level(MIXcd));
  871.             volbar(10,get_level(MIXline));
  872.             volbar(11,get_level(MIXmicrophone));
  873.  
  874.             outn(59,14,((long)get_level(MIXtreble)*107)/255);
  875.             outc(62,14,'%')
  876.             outn(70,14,((long)get_level(MIXbass)*107)/255);
  877.             outc(73,14,'%');
  878.         }
  879.  
  880.     }
  881.  
  882.     m1 = HIDE_CURSOR;
  883.     mouse_call(&m1,&m2,&m3,&m4);
  884.  
  885.     regset.x.ax = 0x0013;
  886.     int86(0x10, ®set, ®set);
  887.  
  888.     FillLUTBuffer((curpal)%numluts);
  889. }
  890.